{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithm DDPG\n",
    "****\n",
    "Randomly initialize critic network $Q(s,a|\\theta^Q)$ and actor $\\mu(s|\\theta^\\mu)$ with weights $\\theta^Q$ and $\\theta^\\mu$<br>\n",
    "initialize target network $Q'$ and $\\mu'$ with weights $\\theta^{Q'}\\leftarrow \\theta^Q, \\theta^{\\mu'} \\leftarrow \\theta^\\mu$<br>\n",
    "Initialize replay buffer $R$<br>\n",
    "**for** episode = 1, M **do**<br>\n",
    "&nbsp;&nbsp;&nbsp;Initialize a random process $N$ for action exploration<br>\n",
    "&nbsp;&nbsp;&nbsp;Receive initial observation state $s_1$<br>\n",
    "&nbsp;&nbsp;&nbsp;**for** t=1, T **do**<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Select action $a_t=\\mu(s_t|\\theta^\\mu)+N_t$ according to the current policy and exploration noise<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Excute action $a_t$ and observe reward $r_t$ and observe new state $s_{t+1}$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Store transition $(s_t,a_t,r_t,s_{t+1})$ in $R$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Sample a random minibatch of $N$ transitions $(s_i,a_i,r_i,s_{i+1})$ from $R$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Set $y_i=r_i+\\gamma Q'(s_{i+1},\\mu'(s_{i+1}|\\theta^{\\mu'})|\\theta^{Q'})$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Update critic by minimizing the loss: $L=\\frac{1}{N}\\sum_i(y_i-Q(s_i,a_i|\\theta^Q))^2$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Update the actor policy using the sampled policy gradient:\n",
    "$$\n",
    "\\nabla_{\\theta^\\mu}J\\approx\\frac{1}{N}\\sum_i\\nabla_aQ(s,a|\\theta^Q)|_{s=s_i,a=\\mu(s_i)}\\nabla_{\\theta^\\mu}\\mu(s|\\theta^\\mu)|s_i\n",
    "$$\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ubdate the target network:\n",
    "$$\n",
    "\\theta^{Q'}\\leftarrow \\tau \\theta^Q +(1-\\tau)\\theta^{Q'}\\\\\n",
    "\\theta^{\\mu'}\\leftarrow \\tau \\theta^\\mu+(1-\\tau)\\theta^{\\mu'}\n",
    "$$\n",
    "&nbsp;&nbsp;&nbsp;**end for**<br>\n",
    "**end for**<br>\n",
    "\n",
    "tips : $\\mu$ 表示确定策略<br>\n",
    "<br>\n",
    "### 代码表示Loss的计算:<br>\n",
    "* #### Critic Loss :\n",
    "$$\n",
    "\\frac{1}{N} \\sum_i \\overbrace{reward+(1.0-done) * gamma * target\\_value\\_net(next\\_state, target\\_policy\\_net(next\\_state))}^{target\\_value}- \\underbrace{value\\_net(state, action)}_{value}\n",
    "$$\n",
    "* #### Policy Loss :\n",
    "$$\n",
    "\\frac{1}{N} \\sum_i value\\_net(state, policy(state))\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 根据上边伪代码整理出以下表格:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><style type=\"text/css\">\n",
    ".tg  {border-collapse:collapse;border-spacing:0;border-color:#bbb;}\n",
    ".tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:0px;overflow:hidden;word-break:normal;border-top-width:1px;border-bottom-width:1px;border-color:#bbb;color:#594F4F;background-color:#E0FFEB;}\n",
    ".tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:0px;overflow:hidden;word-break:normal;border-top-width:1px;border-bottom-width:1px;border-color:#bbb;color:#493F3F;background-color:#9DE0AD;}\n",
    ".tg .tg-koh6{font-size:36px;border-color:inherit;text-align:left;vertical-align:top}\n",
    ".tg .tg-7ab7{font-weight:bold;font-size:36px;border-color:inherit;text-align:center;vertical-align:top}\n",
    ".tg .tg-bwtg{font-size:36px;border-color:inherit;text-align:center;vertical-align:top}\n",
    ".tg .tg-n9dp{background-color:#C2FFD6;font-size:36px;border-color:inherit;text-align:left;vertical-align:top}\n",
    "</style>\n",
    "<table class=\"tg\">\n",
    "  <tr>\n",
    "    <th class=\"tg-7ab7\">Algorithm</th>\n",
    "    <th class=\"tg-7ab7\">Neural Network</th>\n",
    "    <th class=\"tg-7ab7\">input</th>\n",
    "    <th class=\"tg-7ab7\">output</th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-bwtg\" rowspan=\"2\">Critic</td>\n",
    "    <td class=\"tg-n9dp\">target critic network<br>θ^Q'</td>\n",
    "    <td class=\"tg-koh6\">next state s_{i+1} &amp;&amp;<br>the action a_{i+1} of s_{i+1} through θ^𝜇'</td>\n",
    "    <td class=\"tg-n9dp\">Q'(s_{i+1},a_{i+1})<br><big><big>for critic loss</big></big></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-n9dp\">critic network<br>θ^Q</td>\n",
    "    <td class=\"tg-koh6\">current state s_i &amp;&amp;<br>action in current state a_i</td>\n",
    "    <td class=\"tg-n9dp\">Q(s_i,a_i) <br><big><big>for critic loss and <br>policy loss</big></big></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-bwtg\" rowspan=\"2\">Actor</td>\n",
    "    <td class=\"tg-n9dp\">target actor network<br> θ^𝜇'</td>\n",
    "    <td class=\"tg-koh6\">next state s_{i+1}</td>\n",
    "      <td class=\"tg-n9dp\">action a_{i+1} at<br>state s_{i+1}<br><big><big>for critic loss</big></big></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-n9dp\">actor network <br>θ^𝜇</td>\n",
    "    <td class=\"tg-koh6\">current state s_i</td>\n",
    "    <td class=\"tg-n9dp\">𝜇(s_i)<br><big><big> for policy loss</big></big></td>\n",
    "  </tr>\n",
    "</table></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../assets/DDPG_landscape.png\" width=600 />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 特性总结\n",
    "1. 类似于DQN的replay buffer\n",
    "2. 类似于DQN的target network但此处更新的时候采用soft update\n",
    "3. 使用Actor_net输入s&&s'选择动作a&&a'分别用来更新actor_net和Q_net，使用Q_net输入a&&a'分别用来评估(s,a)和(s',a')来更新actor_net和Q_net\n",
    "4. 只能处理连续动作空间，离散动作不存在确定性策略的说法\n",
    "5. 标准化动作空间,对action 增加噪声\n",
    "6. actor-critic思想，但计算loss function的时候和A2C有很大不同<br>\n",
    "    a. A2C里的Critic loss $\\leftrightarrow$ TD error $\\leftrightarrow$ advantage function<br>\n",
    "    因为$\\hat{A}(s,a)=Q(s,a)-V(s)$是TD error的无偏估计。<br>\n",
    "    而DDPG里critic的计算和DoubleDQN很像，只不过计算target_Q的$a_{i+1}$是用网络$\\theta^{\\mu'}$所得的<br>\n",
    "    b.DDPG计算actor loss的时候估计是为了减少计算量，所以使用的是Q(s,a)而不是A(s,a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Tips:\n",
    "**np.clip $\\leftrightarrow$ torch.clamp <br>**\n",
    "$y_i = \\begin{cases}\n",
    "        \\text{min} & \\text{if } x_i < \\text{min} \\\\\n",
    "        x_i & \\text{if } \\text{min} \\leq x_i \\leq \\text{max} \\\\\n",
    "        \\text{max} & \\text{if } x_i > \\text{max}\n",
    "    \\end{cases}$<br>\n",
    "    <br>\n",
    "**torch.detach() , torch.data:<br>**\n",
    "都是将自动微分截断，也就是进行requires_grad=False操作<br>\n",
    "推荐使用detach()，可以对微分进行追踪<br>\n",
    "DDPG这里，将target_Q.detach()保证只更新value_net<br>\n",
    "<br>\n",
    "**Policy_net输出未加F.tanh()**<br>\n",
    "将动作空间控制在-1~+1哇完了<br>\n",
    "tanh公式为:<br>\n",
    "$\\text{Tanh}(x) = \\tanh(x) = \\frac{e^x - e^{-x}}{e^x + e^{-x}}$\n",
    "<img src=\"../assets/TanhReal.gif\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MountainCarContinuous-v0:感觉该环境可以考虑用HER解决<br>\n",
    "但是我加的噪声是相同的量，就会永远给小车一个向前或者向后的推力,但是这样操作。减少step的话就会没有效果<br>\n",
    "假设这个力是向前的(因为我们最终需要到达对面的山顶)，那么我就可以保持在推力的方向上施加一个向量<br>\n",
    "这个向量有什么作用呢?它可以让我永远是向着目标前进的，即使奖励值很稀疏。但我能sample出十分有用的信息<br>\n",
    "那么问题来了?我要怎么去求这个单位向量，或者说怎么去拟合这个单位向量。nn?<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "import gym\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Normal\n",
    "# from torch.utils.tensorboard import SummaryWriter\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set(color_codes=True)\n",
    "import pdb\n",
    "%matplotlib inline\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 经验回放\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, column, batch_size, buffer_size):\n",
    "        self.current_state = np.zeros((buffer_size, column), dtype=np.float32)\n",
    "        self.next_state = np.zeros((buffer_size, column), dtype=np.float32)\n",
    "        init = lambda buffer_size : np.zeros(buffer_size, dtype=np.float32)\n",
    "        self.action = init(buffer_size)\n",
    "        self.reward = init(buffer_size)\n",
    "        self.done = init(buffer_size)\n",
    "        self.buffer_size, self.batch_size = buffer_size, batch_size\n",
    "        self.size, self.current_index = 0, 0\n",
    "    \n",
    "    def store(self, current_state, action, next_state, reward, done):\n",
    "        self.current_state[self.current_index] = current_state\n",
    "        self.action[self.current_index] = action\n",
    "        self.next_state[self.current_index] = next_state\n",
    "        self.reward[self.current_index] = reward\n",
    "        self.done[self.current_index] = done\n",
    "        self.current_index = (self.current_index + 1) % buffer_size\n",
    "        self.size = min(self.buffer_size, (self.size + 1))\n",
    "    \n",
    "    def sample(self):\n",
    "        index = np.random.choice(self.size, self.batch_size, replace=False)\n",
    "        return dict(current_state = torch.tensor(self.current_state[index],dtype=torch.float).to(device),\n",
    "                    action = torch.tensor(self.action[index]).reshape(-1, 1).to(device),\n",
    "                    next_state = torch.tensor(self.next_state[index],dtype=torch.float).to(device),\n",
    "                    reward = torch.tensor(self.reward[index]).reshape(-1, 1).to(device),\n",
    "                    done = torch.tensor(self.done[index]).reshape(-1, 1).to(device))\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wrapper 将输入数据进行预处理再输入到env中\n",
    "<img src=\"../assets/gym_wrapper.png\" align=center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": [],
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# 对动作空间进行标准化(对输入(_action)输出(_reverse_action)到环境中的action进行标准化)。\n",
    "class NormalizeActions(gym.ActionWrapper):\n",
    "    \n",
    "    def __init__(self, env):\n",
    "        super(NormalizeActions, self).__init__(env)\n",
    "        self.low_bound = self.action_space.low # -2\n",
    "        self.upper_bound = self.action_space.high # +2\n",
    "        \n",
    "    def action(self, action):\n",
    "        # 神经网络使用 tanh 输出的动作在 -1 ~ +1 之间\n",
    "        action = self.low_bound + (action + 1.0) * 0.5 * (self.upper_bound - self.low_bound)\n",
    "        action = np.clip(action, self.low_bound, self.upper_bound)\n",
    "        \n",
    "        return action\n",
    "    \n",
    "    def reverse_action(self, action):\n",
    "        # 对 action 进行反转(reverse)，\n",
    "        action = 2 * (action - self.low_bound) / (self.upper_bound - self.low_bound) - 1\n",
    "        action = np.clip(action, self.low_bound, self.upper_bound)\n",
    "        \n",
    "        return actions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用确定性策略，对action增加噪声\n",
    "class OUNoise:\n",
    "    def __init__(self, action_space, mu=0.0, theta=0.15, max_sigma=0.3, min_sigma=0.1, decay_period=100000):\n",
    "        self.mu = mu\n",
    "        self.theta = theta\n",
    "        self.sigma = max_sigma\n",
    "        self.max_sigma = max_sigma\n",
    "        self.min_sigma = min_sigma\n",
    "        self.decay_period = decay_period\n",
    "        self.action_dim = action_space.shape[0]\n",
    "        self.low = action_space.low\n",
    "        self.high = action_space.high\n",
    "        # get 定义立即执行函数\n",
    "        self.reset()\n",
    "    \n",
    "    def reset(self):\n",
    "        self.state = np.ones(self.action_dim) * self.mu\n",
    "    \n",
    "    def evolve_state(self):\n",
    "        # self.state += [0.0] + 0.3 * np.random.randn(1)\n",
    "        self.state += self.theta * (self.mu - self.state)+np.random.randn(self.action_dim) # *np.sqrt(0.01) * self.sigma\n",
    "        return self.state\n",
    "    \n",
    "    def get_action(self, action, t=0):\n",
    "        # self.sigma = self.max_sigma\n",
    "        self.sigma = self.max_sigma - (self.max_sigma - self.min_sigma) * min(1.0, t / self.decay_period)\n",
    "        return np.clip(action + self.evolve_state(), self.low, self.high)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 两种方式，一种是先训练一层之后再cat。另一种是直接cat\n",
    "class ValueNetwork(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim):\n",
    "        super(ValueNetwork, self).__init__()\n",
    "        self.linear_state = nn.Linear(state_dim, 64)\n",
    "        self.linear_action = nn.Linear(action_dim, 64)\n",
    "        self.linear2 = nn.Linear(128, 32)\n",
    "        self.linear3 = nn.Linear(32, 1)\n",
    "    \n",
    "    def forward(self, state, action):\n",
    "        hidden_state = F.relu(self.linear_state(state))\n",
    "        hidden_action = F.relu(self.linear_action(action))\n",
    "        cat_state_action = torch.cat((hidden_action, hidden_state),dim=1)\n",
    "        hidden2 = F.relu(self.linear2(cat_state_action))\n",
    "        Q = self.linear3(hidden2)\n",
    "        return Q\n",
    "    \n",
    "#     def __init__(self, state_dim, action_dim):\n",
    "#         super(ValueNetwork, self).__init__()\n",
    "#         self.linear1 = nn.Linear(state_dim+action_dim, 256)\n",
    "#         self.linear2 = nn.Linear(256, 256)\n",
    "#         self.linear3 = nn.Linear(256, 1)\n",
    "    \n",
    "#     def forward(self, state, action):\n",
    "#         x = torch.cat((state, action),dim=1)\n",
    "#         x = F.relu(self.linear1(x))\n",
    "#         x = F.relu(self.linear2(x))\n",
    "#         Q = self.linear3(x)\n",
    "#         return Q\n",
    "\n",
    "class PolicyNetwork(nn.Module):\n",
    "    def __init__(self, in_dim, out_dim):\n",
    "        super(PolicyNetwork, self).__init__()\n",
    "        self.linear1 = nn.Linear(in_dim, 128)\n",
    "        self.linear2 = nn.Linear(128, 64)\n",
    "        self.linear3 = nn.Linear(64, out_dim) # (256, 1)\n",
    "    \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = torch.tanh(self.linear3(x))\n",
    "        return x\n",
    "    \n",
    "    def get_action(self, state):\n",
    "        state = torch.tensor(state,dtype=torch.float).unsqueeze(0).to(device)\n",
    "        action = self.forward(state)\n",
    "        return action.detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ddpg_train(batch_size, gamma=0.99, soft_tau=1e-2):\n",
    "    samples = replay_buffer.sample()\n",
    "    state, action, next_state = samples['current_state'], samples['action'], samples['next_state']\n",
    "    reward, done = samples['reward'], samples['done']\n",
    "    \n",
    "    target_value = reward + (1.0-done)*gamma*target_value_net(next_state, target_policy_net(next_state))\n",
    "    value = value_net(state, action)\n",
    "    value_loss = ((value - target_value.detach()).pow(2)).mean()\n",
    "    \n",
    "    policy_loss = -value_net(state, policy_net(state)).mean()\n",
    "    \n",
    "    value_optimizer.zero_grad()\n",
    "    value_loss.backward()\n",
    "    value_optimizer.step()\n",
    "    \n",
    "    policy_optimizer.zero_grad()\n",
    "    policy_loss.backward()\n",
    "    policy_optimizer.step()\n",
    "    \n",
    "    for target_param, param in zip(target_value_net.parameters(), value_net.parameters()):\n",
    "        target_param.data.copy_(target_param.data*(1.0-soft_tau) + param.data*soft_tau)\n",
    "    for target_param, param in zip(target_policy_net.parameters(), policy_net.parameters()):\n",
    "        target_param.data.copy_(target_param.data*(1.0-soft_tau) + param.data*soft_tau)\n",
    "    \n",
    "    return value_loss.item(), policy_loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# env = NormalizeActions(gym.make(\"Pendulum-v0\"))\n",
    "env = NormalizeActions(gym.make(\"MountainCarContinuous-v0\"))\n",
    "ou_noise = OUNoise(env.action_space)\n",
    "\n",
    "in_dim = env.observation_space.shape[0] # 3\n",
    "out_dim = env.action_space.shape[0] # 1 连续动作空间\n",
    "\n",
    "value_net = ValueNetwork(in_dim, out_dim).to(device)\n",
    "policy_net = PolicyNetwork(in_dim, out_dim).to(device)\n",
    "\n",
    "target_value_net = ValueNetwork(in_dim, out_dim).to(device)\n",
    "target_policy_net = PolicyNetwork(in_dim, out_dim).to(device)\n",
    "target_value_net.load_state_dict(value_net.state_dict())\n",
    "target_policy_net.load_state_dict(policy_net.state_dict())\n",
    "\n",
    "value_optimizer = optim.Adam(value_net.parameters())\n",
    "policy_optimizer = optim.Adam(policy_net.parameters(), lr=1e-4)\n",
    "\n",
    "buffer_size = 1000000\n",
    "batch_size = 128\n",
    "replay_buffer = ReplayBuffer(in_dim, batch_size, buffer_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "def smooth_plot(factor, item, plot_decay):\n",
    "    item_x = np.arange(len(item))\n",
    "    item_smooth = [np.mean(item[i:i+factor]) if i > factor else np.mean(item[0:i+1])\n",
    "                  for i in range(len(item))]\n",
    "    for i in range(len(item)// plot_decay):\n",
    "        item_x = item_x[::2]\n",
    "        item_smooth = item_smooth[::2]\n",
    "    return item_x, item_smooth\n",
    "    \n",
    "def plot(episode, rewards, value_losses, policy_losses):\n",
    "    clear_output(True)\n",
    "    rewards_x, rewards_smooth = smooth_plot(10, rewards, 500)\n",
    "    value_losses_x, value_losses_smooth = smooth_plot(10, value_losses, 30000)\n",
    "    policy_losses_x, policy_losses_smooth = smooth_plot(10, policy_losses, 30000)\n",
    "    \n",
    "    plt.figure(figsize=(18, 12))\n",
    "    plt.subplot(311)\n",
    "    plt.title('episode %s. reward: %s'%(episode, rewards_smooth[-1]))\n",
    "    plt.plot(rewards, label=\"Rewards\", color='lightsteelblue', linewidth='1')\n",
    "    plt.plot(rewards_x, rewards_smooth, label='Smothed_Rewards', color='darkorange', linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(312)\n",
    "    plt.title('Value_Losses')\n",
    "    plt.plot(value_losses,label=\"Value_Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(value_losses_x, value_losses_smooth, \n",
    "             label=\"Smoothed_Value_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(313)\n",
    "    plt.title('Policy_Losses')\n",
    "    plt.plot(policy_losses,label=\"Policy_Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(policy_losses_x, policy_losses_smooth, \n",
    "             label=\"Smoothed_Policy_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x864 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "episodes = 200\n",
    "steps = 1000\n",
    "value_losses = []\n",
    "policy_losses = []\n",
    "all_rewards = []\n",
    "for episode in range(episodes):\n",
    "    state = env.reset()\n",
    "    ou_noise.reset()\n",
    "    episode_reward = 0\n",
    "    for step in range(steps):\n",
    "        action = policy_net.get_action(state)\n",
    "        action = ou_noise.get_action(action, step)\n",
    "        next_state, reward, done, _ = env.step(action.flatten())\n",
    "        \n",
    "        replay_buffer.store(state, action, next_state.flatten(), reward, done)\n",
    "        if len(replay_buffer) > batch_size :\n",
    "            value_loss, policy_loss = ddpg_train(batch_size)\n",
    "            value_losses.append(value_loss)\n",
    "            policy_losses.append(policy_loss)\n",
    "        \n",
    "        state = next_state\n",
    "        episode_reward += reward\n",
    "        \n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "#     soft_loss = lambda loss : np.mean(loss[-100:]) if len(loss)>=100 else np.mean(loss)\n",
    "#     writer.add_scalar(\"Reward\", episode_reward, episode)\n",
    "#     writer.add_scalar(\"Value_Losses\", soft_loss(value_losses), episode)\n",
    "#     writer.add_scalar(\"Policy_Losses\", soft_loss(policy_losses), episode)\n",
    "    \n",
    "    all_rewards.append(episode_reward)\n",
    "    \n",
    "    plot(episode, all_rewards, value_losses, policy_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# torch.save(policy_net.state_dict(), \"./model/DDPG.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# policy_net_1 = PolicyNetwork(in_dim, out_dim)\n",
    "# policy_net_1.load_state_dict(torch.load(\"./model/DDPG.pth\"))\n",
    "# policy_net_1.eval()\n",
    "\n",
    "import pdb\n",
    "import gym\n",
    "from IPython import display\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "env = gym.make(\"MountainCarContinuous-v0\")\n",
    "state = env.reset()\n",
    "img = plt.imshow(env.render(mode='rgb_array')) # only call this once\n",
    "for _ in range(1000):\n",
    "    img.set_data(env.render(mode='rgb_array')) # just update the data\n",
    "    display.display(plt.gcf())\n",
    "    display.clear_output(wait=True)\n",
    "    policy_net = policy_net.cpu()\n",
    "    \n",
    "    action = policy_net(torch.FloatTensor(state)).detach().numpy()\n",
    "    # action = env.action_space.sample()\n",
    "    next_state, _, done, _ = env.step(action)\n",
    "    if done: \n",
    "        state = env.reset()\n",
    "    state = next_state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**发现训练了大概有12个小时还没完，是我的episode设置太多了，从tensorboard的图中看出大概1个小时就训练收敛了<br>\n",
    "中途停了，所以最后没有画出图来，还好tensorboard有记录**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### 初次训练的图:\n",
    "<img src=\"../assets/ddpg_first_train.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### 未加tanh的训练图:<br>\n",
    "**Reward :**\n",
    "<img src=\"../assets/Reward.png\"><br>\n",
    "**Value_Losses :**\n",
    "<img src=\"../assets/Value_Losses.png\"><br>\n",
    "**Policy_Losses :**\n",
    "<img src=\"../assets/Policy_Losses.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### 有加tanh的训练图:<br>\n",
    "**Reward :**\n",
    "<img src=\"../assets/Reward_with_tanh.png\"><br>\n",
    "**Value_Losses :**\n",
    "<img src=\"../assets/Value_Losses_with_tanh.png\"><br>\n",
    "**Policy_Losses :**\n",
    "<img src=\"../assets/Policy_Losses_with_tanh.png\">"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "oldHeight": 691.0904539999999,
   "position": {
    "height": "712.525px",
    "left": "1171.09px",
    "right": "20px",
    "top": "194px",
    "width": "603.05px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "varInspector_section_display": "block",
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
